6.2 Entscheidungsbäume visualisieren und trainieren#
Im letzten Kapitel haben wir gelernt, wie mit Scikit-Learn ein Entscheidungsbaum für binäre Klassifikationsaufgaben trainiert wird. In diesem Kapitel werden wir uns damit beschäftigen, den trainierten Entscheidungsbaum von Scikit-Learn visualisieren zu lassen. Darüber hinaus lernen wir, was das Gini-Impurity-Kriterion ist und welche weiteren Einstellmöglichkeiten es für Entscheidungsbäume in Scikit-Learn gibt.
Lernziele#
Lernziele
Sie können einen Entscheidungsbaum mit
plot_treevisualisieren.Sie wissen, was die Angaben
samplesundvaluebei der Visualisierung des Entscheidungsbaumes bedeuten.Sie wissen, was das Gini-Impurity-Kriterium ist.
Sie kennen weitere Parameter für Entscheidungsbäume wie
random_state=odercriterion=.
Entscheidungsbäume visualisieren#
Im letzten Kapitel haben wir den Entscheidungsbaum für das Autohaus mit Hilfe
des Moduls Scikit-Learn trainiert. Scikit-Learn bietet in dem Untermodul
sklearn.tree nicht nur Algorithmen für Entscheidungsbäume an, sondern auch ein
dazu passendes Visualisierungswerkzeug. Die Funktion plot_tree zeichnet den
Entscheidungsbaum. Um diese Funktion auszuprobieren, wird zunächst der Datensatz
mit den Autodaten erneut geladen, das Modell Entscheidungsbaum gewählt und
anschließend trainiert.
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
# Sammlung der Daten
daten = pd.DataFrame({
'Kilometerstand [km]': [32908, 20328, 13285, 17162, 27449, 13715, 32889, 3111, 15607, 18295],
'Preis [EUR]': [15960, 20495, 17227, 17851, 5428, 22772, 13581, 16793, 23253, 11382],
'verkauft': [False, True, False, True, False, True, False, True, True, False],
},
index=['Auto 1', 'Auto 2', 'Auto 3', 'Auto 4', 'Auto 5', 'Auto 6', 'Auto 7', 'Auto 8', 'Auto 9', 'Auto 10'])
daten.head(10)
# Auswahl des Modells: Entscheidungsbaum für Klassifikation
modell = DecisionTreeClassifier(random_state=0)
# Adaption der Daten
X = daten[['Kilometerstand [km]', 'Preis [EUR]']]
y = daten['verkauft']
# Training des Modells
modell.fit(X,y)
DecisionTreeClassifier(random_state=0)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
DecisionTreeClassifier(random_state=0)
Nun können wir die Funktion plot_tree importieren und das trainierte Modell
visualisieren lassen.
from sklearn.tree import plot_tree
plot_tree(modell)
[Text(0.4, 0.875, 'x[1] <= 16376.5\ngini = 0.5\nsamples = 10\nvalue = [5, 5]'),
Text(0.2, 0.625, 'gini = 0.0\nsamples = 4\nvalue = [4, 0]'),
Text(0.30000000000000004, 0.75, 'True '),
Text(0.6, 0.625, 'x[0] <= 13500.0\ngini = 0.278\nsamples = 6\nvalue = [1, 5]'),
Text(0.5, 0.75, ' False'),
Text(0.4, 0.375, 'x[0] <= 8198.0\ngini = 0.5\nsamples = 2\nvalue = [1, 1]'),
Text(0.2, 0.125, 'gini = 0.0\nsamples = 1\nvalue = [0, 1]'),
Text(0.6, 0.125, 'gini = 0.0\nsamples = 1\nvalue = [1, 0]'),
Text(0.8, 0.375, 'gini = 0.0\nsamples = 4\nvalue = [0, 4]')]
plot_tree produziert eine Textausgabe und ein Diagramm. Die Textausgabe kann
unterdrückt werden, indem hinter den Funktionsaufruf plot_tree(modell) ein
Semikolon ; gesetzt wird. Das Diagramm zeichnet wie erwartet die Baumstruktur
vom Wurzelknoten über die Knoten und Zweige bis hin zu den Blättern. Die
Entscheidungsfragen stehen in der erste Zeile der Knoten. Danach folgen weitere
Angaben wie gini, samples und value. Um diese Angaben zu erklären,
ergänzen wir zunächst weitere Angaben. Mit der Option feature_names= wird eine
Liste mit den Eigenschaften ergänzt, die Option class_names= ergänzt die
Klassenbezeichnugnen. So erhalten wir folgendes Diagramm:
plot_tree(modell,
feature_names=['Kilometerstand [km]', 'Preis [EUR]'],
class_names=['nicht verkauft', 'verkauft']);
Was gini bedeuten könnte, erschließt sich so immer noch nicht, aber die
Angaben samples und values können so leichter von ihrer Bedeutung her
eingeordnet werden. samples gibt die Anzahl der Datenobjekte an, die sich in
diesem Knoten befinden. values listet auf, wie viele Datenobjekte die
Zielgröße nicht verkauft (= False bzw. 0) haben und wie viele zu der Klasse
verkauft (= True bzw. 1) gehören.
Weitere Details zu den Optionen der plot_tree-Funktion finden Sie in der
Dokumentation Scikit-Learn →
plot_tree.
Als nächstes widmen wir uns der Bedeutung von gini.
Was ist das Gini-Impurity-Kriterium?#
Das Gini-Impurity-Kriterium ist ein Maß für die Unreinheit eines Datensatzes. Beim Beispiel mit dem Autohaus sind im Wurzelknoten fünf Autos, die nicht verkauft wurden, und fünf verkaufte Autos. Bei zwei Klassen ist das die maximale Unreinheit, die auftreten kann. Der Anteil der verkauften Autos ist genau 50 %. Diesem prozentualen Anteil wird das Gini-Impurity-Kriterium von 0.5 zugeordnet. Es gibt zwei weitere Extremfälle. Entweder sind nur verkaufte Autos im Datensatz (100 % verkaufte Autos) oder gar keine verkaufte Autos (0 % verkaufte Autos). In beiden Fällen ist der Datensatz rein, das Gini-Impurity-Kriterium ist 0. In allen anderen Fällen liegt das Gini-Impurity-Kriterium zwischen 0 und 0.5. Die Formel zur Berechnung des genauen Wertes des Gini-Impurity-Kriteriums lautet
wenn \(p\) der prozentuale Anteil der verkauften Autos ist (das gilt natürlich allgemein für binäre Klassifikationsaufgaben und nicht nur das Autohaus-Beispiel).
Die folgende Abbildung zeigt die konkreten Werte des Gini-Impurity-Kriteriums für den prozentualen Anteil an verkauften Autos.
from numpy import linspace
p = linspace(0,1)
gini = 1 - p**2 - (1-p)**2
import plotly.express as px
fig = px.line(x = p, y = gini,
title='Gini-Impurity-Kriterium',
labels={'x': 'prozentualer Anteil', 'y': 'Wert des Gini-Impurity-Kriteriums'})
fig.show()
Im Diagramm können wir direkt ablesen, dass bei einem nicht verkauften Auto und fünf verkauften Autos (\(p = 0.8\bar{3}\)) das Gini-Impurity-Kriterium den Wert \(0.27\bar{7} \approx 0.278\) hat.
Das Gini-Impurity-Kriterium ist sehr wichtig für das Training eines Entscheidungsbaumes. Der Algorithmus probiert im Hintergrund verschiedene Möglichkeiten durch, mit Hilfe der Entscheidungsfragen den Datensatz zu splitten. Zu jedem Split werden dann die zugehörigen Werte des Gini-Impurity-Kriteriums berechnet. Dann wählt der Algorithmus den Split aus, der die höchste Reinheit hat (also den niedrigsten Gini-Impurity-Wert). Gilt das für mehrere Splits, dann wird zufällig ein Split ausgewählt.
Neben dem Gini-Impurity-Kriterium gibt es noch weitere Bewertungsmaße, um einen
Entscheidungsbaum zu trainieren. In Scikit-Learn sind die beiden Alternativen
log_less und entropy für den Shannonschen Informationsgewinn verfügbar.
Wir schauen uns im Folgenden an, wie diese ausgewählt werden können. Wer zuvor
sich noch ein wenig mehr mit den Details von Entscheidungsbäumen beschäftigen
möchte, kann sich die folgenden Videos ansehen.
Optionales Video “Entscheidungsbäume #2 - Der ID3-Algorithmus” von The Morpheus Tutorials
Optionales Video “Entscheidungsbäume #3 - Entropie und Informationsgewinn” von The Morpheus Tutorials
Optionales Video “ID3 Entscheidungsbaum” von 42 Entwickler
Entscheidungsbäume trainieren#
Der Entscheidungsbaum-Klassifikationsalgorithmus von Scikit-Learn bietet noch weitere Optionen an, wie die Hilfe verrät
help(DecisionTreeClassifier())
oder in der Dokumentation Scikit-Learn → DecisionTreeClassifier() nachgelesen werden kann.
Sowohl bei der Initalisierung des Entscheidungsbaumes können Parameter gesetzt
werden, als auch beim Verwenden der verschiedenen Methoden. Tatsächlich haben
wir bereits weiter oben aus didaktischen Gründen den Parameter random_state=0
bei der Initialisierung gesetzt, damit immer der gleiche Entscheidungsbaum
entsteht. In einem echten Projekt würde dieser Parameter nie verwendet werden.
Probieren Sie andere Werte für den Start des Zufallszahlengenerators aus und testen Sie, was sich verändert, wenn Sie andere Kriterien für das Splitting verwenden.
modell = DecisionTreeClassifier(criterion='entropy', random_state=3)
modell.fit(X,y)
plot_tree(modell,
feature_names=['Kilometerstand [km]', 'Preis [EUR]'],
class_names=['nicht verkauft', 'verkauft']);
Zusammenfassung und Ausblick#
In diesem Kapitel haben wir das Training von Entscheidungsbäumen mit Hilfe der Bibliothek Scikit-Learn vertieft. Im nächsten Kapitel widmen wir uns den Vor-, aber auch den Nachteilen von Entscheidungsbäumen.